﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;
using System.Data.SqlClient;
using QCM.Contract1;
using System.Data;

namespace WcfServiceLibraryPbMetaData
{
	// REMARQUE : si vous modifiez le nom de classe « Service1 » ici, vous devez également mettre à jour la référence à « Service1 » dans App.config.
	public class Service1 :IContractContract
    {
        int nbAppel;
        public int NbAppel
        {
            get { return this.nbAppel; }
            set { this.nbAppel = value; }

        }

        static int nbInstance;
        public static int NbInstance
        {
            get { return nbInstance; }
            set { nbInstance = value; }
        }

        SqlCommand cmd;
        SqlConnection cnx;

        public Service1()
        {
            NbAppel = 0;
            NbInstance++;
//            GC.Collect();

            cnx = new SqlConnection(WcfServiceLibraryPbMetaData.Properties.Settings.Default.ConnectDataBase);

            cmd = new SqlCommand();
            cmd.CommandText = "GetCategories";
            cmd.CommandType = CommandType.StoredProcedure;
            cmd.Connection = cnx;
        }

        #region ICategorie Membres

        public List<Categorie> GetCategories()
        {
            NbAppel++;
            List<Categorie> categories = new List<Categorie>();
            try
            {
                cmd.Connection.Open();
                using (SqlDataReader sdr = cmd.ExecuteReader())
                {
                    while (sdr.Read())
                    {
                        categories.Add(new Categorie((int)sdr["Id"], (String)sdr["Nom"],
                            sdr["Mere"].GetType() == Type.GetType("System.DBNull")? String.Empty: (string)sdr["Mere"]));
                    }
                }
            }
            catch(Exception e)
            {
                //throw new FaultException(e.Message, new FaultCode("PbDataBase"));
                SQLFaultException sfe = new SQLFaultException();
                sfe.code = "PbDataBase";
                sfe.message = e.Message;
                sfe.reason = "Impossible de ce connecter à la base de données";
                throw new FaultException<SQLFaultException>(sfe);
            }
            finally
            {
                if (cmd.Connection.State == ConnectionState.Open)
                    cmd.Connection.Close();
            }

            return categories;
        }

        #endregion

        #region IQuestionnaire Membres

        SqlCommand cmdGetQuestionnaire = null;
        public Questionnaire GetQuestionnaire(int id)
        {
            NbAppel++;
            Questionnaire questionnaire = null;
            //Je recupere les informations globales du questionnaire
            if (cmdGetQuestionnaire == null)
            {
                cmdGetQuestionnaire = new SqlCommand();
                cmdGetQuestionnaire.CommandText = "GetQuestionnaire";
                cmdGetQuestionnaire.CommandType = CommandType.StoredProcedure;
                cmdGetQuestionnaire.Connection = cnx;
                cmdGetQuestionnaire.Parameters.Add(new SqlParameter("@IdQuestionnaire", SqlDbType.Int));
            }
            try
            {
                cmdGetQuestionnaire.Parameters["@IdQuestionnaire"].Value = id;
                cmdGetQuestionnaire.Connection.Open();
                using (SqlDataReader sdr = cmdGetQuestionnaire.ExecuteReader())
                {
                    sdr.Read();
                    questionnaire = new Questionnaire((int)sdr["Id"],(string)sdr["Nom"], (string)sdr["Descriptif"]);
                }
            }
            catch ( SqlException exp )
            {

            }
            catch
            {
                throw new Exception("FAIL");
            }
            finally
            {
                if ( cmdGetQuestionnaire.Connection.State == ConnectionState.Open )
                {
                    cmdGetQuestionnaire.Connection.Close() ;
                }
            }

            //J'appelle GetQuestions et j'insert les resultats dans l'objet Questionnaire
            questionnaire.Questions = GetQuestions(id) ;
            return questionnaire ;
        }

        SqlCommand cmdTitre = null;
        public List<int> GetQuestionnaires(int idCategorie)
        {
            NbAppel++;
            List<int> questionnaires = new List<int>();
            if (cmdTitre == null)
            {
                cmdTitre = new SqlCommand();
                cmdTitre.CommandText = "GetQuestionnaires";
                cmdTitre.CommandType = CommandType.StoredProcedure;
                cmdTitre.Connection = cnx;
                cmdTitre.Parameters.Add(new SqlParameter("@IdCategorie", SqlDbType.Int));
            }

            try
            {
                cmdTitre.Parameters["@IdCategorie"].Value = idCategorie;
                cmdTitre.Connection.Open();
                using (SqlDataReader sdr = cmdTitre.ExecuteReader())
                {
                    while (sdr.Read())
                    {
                        questionnaires.Add((int)sdr["Id"]);
                    }
                }
            }
            catch (Exception e)
            {
                // TODO: implementation a faire lors de la mise en place de WCF
                throw new Exception("Echec dans l'execution de GetQuestionnaires : "+ e.Message + " | STACK TRACE : " + e.StackTrace);
            }
            finally
            {
                if (cmdTitre.Connection.State == ConnectionState.Open)
                    cmdTitre.Connection.Close();
            }
            return questionnaires;
        }

        #endregion

        #region IReponse Membres
        SqlCommand cmdGetReponses = null;
        public List<Reponse> GetReponses(int idQuestion)
        {
            List<Reponse> res = new List<Reponse>();
            if (cmdGetReponses == null)
            {
                cmdGetReponses = new SqlCommand();
                cmdGetReponses.CommandText = "GetReponses";
                cmdGetReponses.CommandType = CommandType.StoredProcedure;
                cmdGetReponses.Connection = cnx;
                cmdGetReponses.Parameters.Add(new SqlParameter("@IdQuestion", SqlDbType.Int));
            }           
            try
            {
                cmdGetReponses.Parameters["@IdQuestion"].Value = idQuestion;
                cmdGetReponses.Connection.Open();
                using (SqlDataReader sdr = cmdGetReponses.ExecuteReader())
                {
                    while (sdr.Read())
                    {
                        res.Add(new Reponse((int)sdr["Id"],(string)sdr["Text"],(int)sdr["Valeur"]));
                    }
                }
            }
            catch
            {
                // TODO: implementation a faire lors de la mise en place de WCF
                throw new Exception("Echec dans l'execution de GetReponse");
            }
            finally
            {
                if (cmdGetReponses.Connection.State == ConnectionState.Open)
                    cmdGetReponses.Connection.Close();
            }
            return res;
        }

        #endregion

        #region IQuestion Membres
        SqlCommand cmdGetQuestions = null;

        /// <summary>
        /// Retourne l'ensemble des questions et les reponses associées
        /// </summary>
        /// <param name="idQuestionnaire">Nom du questionnaire dans lequel recuperer les questions</param>
        /// <returns></returns>
        public List<Question> GetQuestions(int idQuestionnaire)
        {
            List<Question> questions = new List<Question>();
            if (cmdGetQuestions == null)
            {
                cmdGetQuestions = new SqlCommand();
                cmdGetQuestions.CommandText = "GetQuestions";
                cmdGetQuestions.CommandType = CommandType.StoredProcedure;
                cmdGetQuestions.Connection = cnx;
                cmdGetQuestions.Parameters.Add(new SqlParameter("@IdQuestionnaire", SqlDbType.Int));
            }

            
            //Je recup les id des questions associées au questionnaire
            try
            {
                cmdGetQuestions.Parameters["@IdQuestionnaire"].Value = idQuestionnaire;
                cmdGetQuestions.Connection.Open();
                using (SqlDataReader sdr = cmdGetQuestions.ExecuteReader())
                {
                    //Pour chaque Id je crée un objet Question avec ses reponses
                    while (sdr.Read())
                    {
                        questions.Add(new Question((int)sdr["Id"], (string)sdr["Titre"]));
                    }
                }
            }
            catch
            {
                // TODO: implement(ation a faire lors de la mise en place de WCF
//                throw new Exception("Echec dans l'execution de GetIdQuestions");
            }
            finally
            {
                if (cmdGetQuestions.Connection.State == ConnectionState.Open)
                    cmdGetQuestions.Connection.Close();

                foreach (Question question in questions) 
                {
                    question.Reponses = GetReponses(question.Id);
                }
            }
            return questions;
        }

        #endregion
    }
}
